home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / StyledText.C < prev    next >
C/C++ Source or Header  |  1990-12-07  |  19KB  |  891 lines
  1. //$StyledText,StyledTextIter,Style,StyleTable,TextRunArray$
  2.  
  3. #include "StyledText.h"
  4. #include "RunArray.h"
  5. #include "Mark.h"
  6. #include "Port.h"
  7. #include "Error.h"
  8. #include "ObjectTable.h"
  9.  
  10. //------ StyleSpec ------------------------------------------------------
  11.  
  12. StyleSpec::StyleSpec()
  13. { 
  14.     font= eFontChicago; 
  15.     face= eFacePlain; 
  16.     size= 12; 
  17.     ink= ePatBlack; 
  18.     xor= TRUE; 
  19. }
  20.     
  21. StyleSpec::StyleSpec(Font *fp, GrPattern c, bool mode)
  22. { 
  23.     font= fp->Fid(); 
  24.     face= fp->Face(); 
  25.     size= fp->Size(); 
  26.     ink= c; 
  27.     xor= mode; 
  28. }
  29.  
  30. StyleSpec::StyleSpec(GrFont ft, GrFace fc, int sz, GrPattern c, bool mode)
  31. { 
  32.     font= ft; 
  33.     face= fc; 
  34.     size= sz; 
  35.     ink= c; 
  36.     xor= mode; 
  37. }
  38.  
  39. //------ StyleTable ------------------------------------------------------
  40.  
  41. class StyleTable: public OrdCollection {
  42. public:
  43.     MetaDef(StyleTable);
  44.     StyleTable() : OrdCollection(cCollectionInitCap)
  45.     { ObjectTable::AddRoot(this); }
  46.     Style *MakeStyle(GrFont ft, GrFace fc, int size, GrPattern ink);
  47.     Style *MakeStyle(Style *);
  48. };
  49.  
  50. static StyleTable *Styles;
  51.  
  52. MetaImpl0(StyleTable); 
  53.  
  54. Style *StyleTable::MakeStyle(GrFont ft, GrFace fc, int size, GrPattern ink)
  55. {
  56.     Iter next(this);
  57.     register Style *sp;
  58.     while (sp= (Style*)next()) {
  59.     register Font *f= sp->fp;
  60.     if (f->Fid() == ft && f->Size() == size && f->Face() == fc &&
  61.         sp->ink == ink) 
  62.         return sp;
  63.     }
  64.     sp= new_Style(0, new_Font(ft, size, fc), ink);
  65.     Add(sp);
  66.     return sp;
  67. }
  68.  
  69. Style *StyleTable::MakeStyle(Style *asp)
  70. {
  71.     Iter next(this);
  72.     Style *sp;
  73.     while (sp= (Style*)next()) 
  74.     if (sp->IsEqual(asp))
  75.         return sp;
  76.     Add(asp);
  77.     return asp;
  78. }
  79.  
  80. //------ Style -----------------------------------------------------------
  81.  
  82. MetaImpl(Style, (TP(fp), TP(ink), 0)); 
  83.  
  84. Style::Style(int, FontPtr f, GrPattern c)
  85. {
  86.     fp= f;  
  87.     ink= c;  
  88. }
  89.  
  90. Style *new_Style(int i, FontPtr f, GrPattern c)
  91. {
  92.     return new Style(i, f, c);
  93. }
  94.  
  95. Style *new_Style(FontPtr f, GrPattern c)
  96. {
  97.     if (Styles == 0)
  98.     Styles= new StyleTable;
  99.     return Styles->MakeStyle(f->Fid(), f->Face(), f->Size(), c);
  100. }
  101.  
  102. Style *new_Style(GrFont ft, GrFace fc, int size, GrPattern ink)
  103. {
  104.     if (Styles == 0)
  105.     Styles= new StyleTable;
  106.     return Styles->MakeStyle(ft, fc, size, ink);
  107. }
  108.  
  109. Style::~Style()
  110. { 
  111.     this= 0;
  112. }
  113.  
  114. ostream &Style::PrintOn(ostream &s) 
  115. {    
  116.     return s << fp SP << ink SP;
  117. }
  118.  
  119. istream &Style::ReadFrom(istream &s) 
  120. { 
  121.     char c;
  122.     
  123.     s >> fp;
  124.     s.eatwhite();
  125.     s.get(c);
  126.     s.putback(c);
  127.     if (c != '}')       // new Style with ink
  128.     s >> ink;
  129.     else                // old Style without ink
  130.     ink= ePatBlack;
  131.     return s;
  132. }
  133.  
  134. ostream &Style::DisplayOn(ostream &s) 
  135. {
  136.     return s << fp->AsString() NL;
  137. }
  138.  
  139. bool Style::IsEqual(Object* op)
  140. {
  141.     if (!op->IsKindOf(Style))
  142.     return FALSE;
  143.  
  144.     Style *sp= (Style*)op;
  145.     register Font *f= sp->fp;
  146.     return (f->Fid() == fp->Fid() && 
  147.         f->Size() == fp->Size() && 
  148.         f->Face() == fp->Face() &&
  149.         ink == sp->ink);
  150. }
  151.  
  152. void Style::GetStyle(GrFont *fid, GrFace *face, int *size, GrPattern *col)
  153. {
  154.     *fid= fp->Fid();
  155.     *face= fp->Face();
  156.     *size= fp->Size();
  157.     *col= ink;
  158. }
  159.  
  160. ObjPtr Style::DeepClone()
  161. {
  162.     return this;
  163. }
  164.  
  165. //---- class TextRunArray --------------------------------------------------
  166.  
  167. MetaImpl(TextRunArray, (TP(st), 0)); 
  168.  
  169. TextRunArray::TextRunArray(StyledText *sp, int elements) : RunArray(elements)
  170. {
  171.     st= sp;
  172. }
  173.  
  174. ObjPtr TextRunArray::RunAt(int i, int *start, int *end, int *size ,int *lenat)
  175. {
  176.     // requests for styles beyond the end of the text receive the
  177.     // same style information as at the end of the text
  178.     int at= i;
  179.     i= min(i, Size()-1);
  180.     if (i < 0) { // take styleHere into account
  181.     *start= *end= at;
  182.     *size= *lenat= 0;
  183.     return (ObjPtr)st->GetCurrentStyle();
  184.     }
  185.     return RunArray::RunAt(i, start, end, size, lenat);
  186. }
  187.  
  188. ostream &TextRunArray::PrintOn(ostream &s) 
  189. {
  190.     RunArray::PrintOn(s);
  191.     return s << st SP;
  192. }
  193.  
  194. istream &TextRunArray::ReadFrom(istream &s) 
  195. { 
  196.     RunArray::ReadFrom(s);
  197.     return s >> st;
  198. }
  199.  
  200. Object *TextRunArray::ReadItem(istream& s)
  201. {
  202.     Style *sp;
  203.     s >> sp;
  204.     if (Styles == 0)
  205.     Styles= new StyleTable;
  206.     sp= Styles->MakeStyle(sp);
  207.     return sp;    
  208. }
  209.  
  210. //----- class StyledTextIter ---------------------------------------------
  211.  
  212. StyledTextIter::StyledTextIter(Text *s, int from, int to) 
  213.                               : GapTextIter(s, from, to)
  214. {
  215.     if (!s->IsKindOf(StyledText))
  216.     Error("StyledTextIter::StyledTextIter", "StyledText expected (%s received)",
  217.                                 s->ClassName());
  218.     nextFontChange= ce;
  219.     NextFontChange();
  220.     if (sp == 0) {
  221.     sp= new_Style(gSysFont);
  222.     Error("StyledTextIter::StyledTextIter", "style is nil");
  223.     }
  224. }
  225.  
  226. void StyledTextIter::Reset(Text *s, int from, int to)
  227. { 
  228.     if (!s->IsKindOf(StyledText))
  229.     Error("StyledTextIter::Reset", "StyledText expected (%s received)",
  230.                                 s->ClassName());
  231.     GapTextIter::Reset(s,from,to);
  232.     nextFontChange= ce;
  233.     NextFontChange();
  234.     if (sp == 0) {
  235.     sp= new_Style(gSysFont);
  236.     Error("StyledTextIter::Reset", "style is nil");
  237.     }
  238. }
  239.  
  240. int StyledTextIter::operator()()  
  241. {
  242.     return GapTextIter::operator()();
  243. }
  244.  
  245. int StyledTextIter::Line(LineDesc *ld)
  246. {
  247.     register StyledText *pt = (StyledText*)ct;
  248.     unget = ce;
  249.     NextFontChange();
  250.     if (ld) 
  251.     ld->FromFont(sp->GetStyle());
  252.  
  253.     if (ce == upto) { // special case if last line is empty
  254.     int last = pt->CharAt(ce-1);
  255.     ce++;
  256.     if (last == '\n' || last == '\r')
  257.         return upto;
  258.     }
  259.     if (ce > upto)
  260.     return cEOT;
  261.  
  262.     while (ce < upto) {
  263.     int ch = pt->CharAt(ce);
  264.     if (NextFontChange() && ld)
  265.         ld->Max(sp->GetStyle());
  266.     if (DoEscape(ce,ch)) 
  267.         pt->CalcEscape(ce,ld);
  268.     ce++;
  269.     if (ch == '\n' || ch == '\r')
  270.         break;
  271.     }
  272.     return ce;
  273. }
  274.  
  275. int StyledTextIter::operator()(int *w, LineDesc *ld)  
  276. {
  277.     register StyledText *pt = (StyledText*)ct;
  278.  
  279.     *w = 0;
  280.     if (ce == upto )
  281.     return cEOT;
  282.  
  283.     NextFontChange();
  284.     int ch = CharAt(ce);
  285.     if (DoEscape(ce,ch))
  286.     *w = pt->CalcEscape(ce,ld);
  287.     else {      
  288.     *w = sp->GetStyle()->Width(ch);
  289.     if (ld)
  290.         ld->FromFont(sp->GetStyle());
  291.     }
  292.     ce++;
  293.     return ch;
  294. }
  295.  
  296. int StyledTextIter::Token(int *w,LineDesc *ld)  
  297. {
  298.     register StyledText *pt = (StyledText*)ct;
  299.  
  300.     unget= ce;
  301.     *w = 0;
  302.     NextFontChange();
  303.     if (ld) 
  304.     ld->FromFont(sp->GetStyle());
  305.     if (ce >= upto)
  306.     return cEOT;
  307.     register int ch= CharAt(ce);
  308.     if (Isspace(ch)) {
  309.     *w = sp->GetStyle()->Width(ch);
  310.     ce++;
  311.     return (ch);
  312.     } else if (DoEscape(ce,ch)) {
  313.     *w = pt->CalcEscape(ce,ld);
  314.     ce++;
  315.     return (ch);
  316.     }
  317.     while (ce < upto && !Isspace(CharAt(ce)) && !DoEscape(ce,CharAt(ce))) {
  318.     if (NextFontChange() && ld)
  319.         ld->Max(sp->GetStyle());
  320.     ch = CharAt(ce++);
  321.     *w += sp->GetStyle()->Width(ch);
  322.     }
  323.     return (ch);
  324. }
  325.  
  326. bool StyledTextIter::NextFontChange ()
  327. { 
  328.     if (ce == nextFontChange) {
  329.     sp = (Style*)  ((StyledText*)ct)->styles->RunAt(ce,&start,&end,&size,&lenat);
  330.     nextFontChange = ce + lenat;
  331.     return TRUE;
  332.     }
  333.     else
  334.     return FALSE;
  335. }
  336.  
  337. //----- class StyledText --------------------------------------------------
  338.  
  339. MetaImpl(StyledText, (TP(styles), TP(sp), TP(styleHere), T(applyStyleHere),
  340.     /* T(escape), */ T(nextFontChange), T(start), T(end), 
  341.     T(size), T(lenat), 0));    
  342.  
  343. static TextChanges changeRec;
  344.  
  345. StyledText::StyledText()
  346. {
  347.     styles= new TextRunArray(this);
  348.     Init(gSysFont, TRUE);
  349. }
  350.  
  351. StyledText::StyledText(int size, FontPtr fd) : GapText(size, fd)
  352. {
  353.     styles= new TextRunArray(this);
  354.     Init(fd, TRUE);
  355. }
  356.  
  357. StyledText::StyledText(byte *buf, int len, bool ic, FontPtr fd)  
  358.                              : GapText(buf, len, ic, fd)
  359. {
  360.     styles= new TextRunArray(this);
  361.  
  362.     if (Size()) {
  363.     styles->Insert(new_Style(fd), 0, 0, Size());
  364.     Init(gSysFont, FALSE);
  365.     } else 
  366.     Init(fd, TRUE);
  367. }
  368.  
  369. StyledText::StyledText(TextRunArray *st, byte *buf, int len, bool ic)
  370.                             : GapText(buf, len, ic)
  371. {
  372.     if (st->Size() != Size())
  373.     Error("StyledText", "StyleArray does not correspond to the text");
  374.     styles= st;
  375.     Init(gSysFont, FALSE);
  376. }
  377.  
  378. StyledText::StyledText(FontPtr fd, char* va_(fmt), ...)
  379. {
  380.     Style *st= new_Style(fd);
  381.     char *buf;
  382.  
  383.     va_list ap;
  384.     va_start(ap,va_(fmt));
  385.     buf= strvprintf(va_(fmt), ap);
  386.     va_end(ap);
  387.     BuildStylesFromString(st, buf);
  388.     Init(fd, FALSE);
  389.     SafeDelete(buf);
  390. }
  391.  
  392. StyledText::~StyledText()
  393. {
  394.     SafeDelete(styles);
  395.     SafeDelete(styleHere);
  396. }
  397.  
  398. void StyledText::InitNew()
  399. {
  400.     GapText::InitNew();
  401.     styles= new TextRunArray(this);
  402.     Init(gSysFont, TRUE);
  403. }
  404.  
  405. void StyledText::Init(FontPtr fd, bool nullStyle)
  406. {
  407.     styleHere= new_Style(fd);
  408.     if (nullStyle)
  409.     applyStyleHere= nullStyle;
  410.     escape= '0';
  411. }
  412.  
  413. void StyledText::ReplaceWithStr(byte *str,int len)
  414. {
  415.     GapText::ReplaceWithStr(str, len);
  416.     SafeDelete(styles);
  417.     Init(GetFont(), FALSE);   
  418. }
  419.  
  420. void StyledText::Cut(int from,int to)
  421. {
  422.     int start, end, size, lenat;
  423.     DoDelayChanges dc(this);
  424.     // if we delete a complete run |xxxx|XXXXXXX
  425.     //                             ^         ^ we will set styleHere
  426.  
  427.     Style *sp= (Style*)styles->RunAt(from,&start,&end,&size,&lenat);
  428.     applyStyleHere = FALSE;
  429.     if (start == from && size <= to - from) {
  430.     applyStyleHere = TRUE;
  431.     styleHere = sp;
  432.     }
  433.     GapText::Cut(from,to);
  434.     styles->Cut(from,to,FALSE);
  435. }
  436.  
  437. void StyledText::Paste(Text* t,int from,int to)
  438. {
  439.     DoDelayChanges dc(this);
  440.     GapText::Paste(t,from,to);
  441.     if (t->IsKindOf(StyledText)) { 
  442.     StyledText *st = (StyledText *)t;
  443.     if (styles)
  444.         styles->Paste(st->styles, from, to, FALSE);
  445.     else
  446.         Error("Paste", "styles == 0");
  447.     }  else {
  448.     int start, end, size, lenat;
  449.     if (from != to) {
  450.         Style *sp= (Style*)styles->RunAt(from, &start, &end, &size, &lenat);
  451.         if (start == from && size <= to - from) {
  452.         applyStyleHere= TRUE;
  453.         styleHere= sp;
  454.         }
  455.         styles->Cut(from,to,FALSE);
  456.     }
  457.     if (applyStyleHere && t->Size()) { // insert new run with styleHere
  458.         //styles->Insert (new_Style(styleHere->GetStyle()), from, from, t->Size());
  459.         styles->Insert (styleHere,from ,from , t->Size());
  460.         applyStyleHere= FALSE;
  461.     }
  462.     else 
  463.         styles->ChangeRunSize(from, t->Size());
  464.     }       
  465. }
  466.  
  467. void StyledText::Copy(Text* save,int from, int to)
  468. {
  469.     if (!CheckRange(Size(),from,to) || save == 0)
  470.     return;
  471.     GapText::Copy(save,from,to);
  472.  
  473.     if (!save->IsKindOf(StyledText)) 
  474.     return;
  475.  
  476.     StyledText *st = (StyledText *)save;
  477.     if (applyStyleHere && Size() == 0) {
  478.     st->applyStyleHere = TRUE;
  479.     st->styleHere = styleHere;
  480.     } else 
  481.     styles->Copy(st->styles,from,to);
  482. }
  483.  
  484. TextPtr StyledText::Save(int from, int to)
  485. {
  486.     if (!CheckRange(Size(),from,to))
  487.     return 0;
  488.  
  489.     StyledText* t= new StyledText(to-from);
  490.     Copy(t, from, to);
  491.     return t;
  492. }
  493.  
  494. void StyledText::SetFStringVL(char *fmt, va_list ap)
  495. {
  496.     char *buf= strvprintf(fmt, ap);
  497.     FontPtr fd= GetFont();
  498.     Empty();
  499.     Style *st= GetStyle(0);
  500.     BuildStylesFromString(st, buf);
  501.     SafeDelete(buf);
  502.     Init(fd, FALSE);
  503. }
  504.  
  505. void StyledText::Insert(byte c, int from,int to)
  506. {
  507.     DoDelayChanges dc(this);
  508.     GapText::Insert(c,from,to);
  509.     if (applyStyleHere)  { // insert new run with styleHere 
  510.     styles->Insert(new_Style(styleHere->GetStyle()), from, from, 1);
  511.     applyStyleHere= FALSE;
  512.     } else 
  513.     styles->ChangeRunSize(from,1);
  514. }
  515.  
  516. Text *StyledText::GetScratchText(int size)
  517. {
  518.     return new GapText(size);
  519. }
  520.  
  521. void StyledText::DrawText(int from, int to, Rectangle clip)
  522. {
  523.     if (!CheckRange(Size(), from ,to))
  524.     return;
  525.     int ch;
  526.     nextFontChange= from;
  527.     NextFontChange(from);
  528.     GrSetFont(sp->GetStyle());
  529.     GrSetTextPattern(sp->GetInk());
  530.  
  531.     Point start= GrGetTextPos();
  532.     for (int i= from; i < to; i++) {
  533.     if (NextFontChange(i)) {
  534.         GrSetFont(sp->GetStyle());
  535.         GrSetTextPattern(sp->GetInk());
  536.     }
  537.     if ((ch= CharAt(i)) == '\t') 
  538.         GrTextAdvance(Tabulate(GrGetTextPos().x-start.x)); 
  539.     else if (DoEscape(i,ch)) {
  540.         DrawEscape(i,clip);
  541.         NextFontChange(nextFontChange = i); // reload current style
  542.         GrSetFont(sp->GetStyle());
  543.         GrSetTextPattern(sp->GetInk());
  544.     } else
  545.         GrDrawChar(ch);
  546.     }
  547. }
  548.  
  549. void StyledText::DrawTextJust (int from, int to, int w, Point start, Rectangle r)
  550. {
  551.     register byte ch;
  552.     int ntab, longBlanks, addSpace, seenTabs;
  553.  
  554.     if (!CheckRange(Size(), from, to))
  555.     return;
  556.  
  557.     ntab= longBlanks= seenTabs = 0;
  558.  
  559.     CalcIws(w, from, &to, &addSpace, &longBlanks, &ntab);    
  560.     GrTextMoveto(start);
  561.     NextFontChange(nextFontChange= from);
  562.     GrSetFont(sp->GetStyle());
  563.     GrSetTextPattern(sp->GetInk());
  564.     for (int i = from, nBlanks = 0; i < to; i++) {
  565.     if (NextFontChange(i)) {
  566.         GrSetFont(sp->GetStyle());
  567.         GrSetTextPattern(sp->GetInk());
  568.     }
  569.     switch (ch = CharAt(i)) {
  570.     case '\t':
  571.         GrTextAdvance(Tabulate(GrGetTextPos().x-start.x));
  572.         seenTabs++;
  573.         break;
  574.     case ' ':
  575.         GrTextAdvance(sp->GetStyle()->Width(' '));
  576.         if (seenTabs == ntab) {
  577.         GrTextAdvance(addSpace);
  578.         if (nBlanks < longBlanks)
  579.             GrTextAdvance(1);
  580.         nBlanks++;
  581.         }
  582.         break;
  583.     default:
  584.         if (DoEscape(i,ch)) {
  585.         DrawEscape(i,r);
  586.         NextFontChange(nextFontChange = i); // reload current style
  587.         GrSetFont(sp->GetStyle());
  588.         GrSetTextPattern(sp->GetInk());
  589.         }
  590.         else
  591.         GrDrawChar (CharAt(i));
  592.     }
  593.     }
  594. }
  595.  
  596. void StyledText::JustifiedMap(int from, int to, int w, int stopAt, int posX, 
  597.                                int *charPos, int *x)
  598. {
  599.     register byte ch;
  600.     int ntab, longBlanks, addSpace, seenTabs, cx, wx;
  601.  
  602.     if (!CheckRange(Size(), from, to))
  603.     return;
  604.  
  605.     wx= cx= ntab= longBlanks= addSpace= seenTabs= 0;
  606.  
  607.     CalcIws(w, from, &to, &addSpace, &longBlanks, &ntab);    
  608.     nextFontChange = from;
  609.  
  610.     for (int i = from, nBlanks = 0; i < to && i < stopAt; i++) {
  611.     NextFontChange(i); 
  612.     switch (ch = CharAt(i)) {
  613.     case '\t':
  614.         wx = Tabulate(cx);
  615.         seenTabs++;
  616.         break;
  617.     case ' ':
  618.         wx= sp->GetStyle()->Width(' ');
  619.         if (seenTabs == ntab) {
  620.         wx += addSpace;
  621.         if (nBlanks < longBlanks)
  622.             wx++; 
  623.         nBlanks++;
  624.         }
  625.         break;
  626.     default:
  627.         if (DoEscape(i,ch)) 
  628.         wx = CalcEscape(i);
  629.         else 
  630.         wx = sp->GetStyle()->Width(ch); 
  631.         break;
  632.     }
  633.     if (cx + (wx/2) > posX)
  634.         break;
  635.     cx += wx;
  636.     }
  637.     if (x)
  638.     *x = cx;
  639.     if (charPos)
  640.     *charPos= i;
  641. }
  642.  
  643. int StyledText::TextWidth(int from, int to)
  644. {
  645.     if (!CheckRange(Size(), from ,to))
  646.     return 0;
  647.  
  648.     int w= 0, ch;
  649.  
  650.     nextFontChange= from;
  651.     NextFontChange(from);
  652.  
  653.     for (int i= from; i < to; i++) {
  654.     NextFontChange(i);
  655.     ch= CharAt(i);
  656.     if (ch == '\t') 
  657.         w+= Tabulate(w); 
  658.     else {
  659.         if (DoEscape(i,ch))
  660.         w+= CalcEscape(i);
  661.         else 
  662.         w+= sp->GetStyle()->Width (ch);
  663.     }
  664.     }
  665.     return w;
  666. }
  667.  
  668. TextIter *StyledText::MakeIterator(int from, int to)
  669. { 
  670.     return new StyledTextIter(this, from, to); 
  671. }
  672.  
  673. ostream &StyledText::PrintOn(ostream &s) 
  674. {
  675.     GapText::PrintOn(s);
  676.     return s << styles SP << (int)escape SP;
  677. }
  678.  
  679. istream &StyledText::ReadFrom(istream &s) 
  680. {
  681.     int esc;
  682.  
  683.     GapText::ReadFrom(s);
  684.     s >> styles >> esc;
  685.     escape= esc;
  686.     applyStyleHere= (Size() == 0);
  687.     return s;
  688. }
  689.  
  690. istream& StyledText::ReadFromAsPureText(istream &s, long sizeHint)
  691. {
  692.     GapText::ReadFromAsPureText(s, sizeHint);
  693.     applyStyleHere= (Size() == 0);
  694.     styleHere= new_Style(GapText::GetFont(0));
  695.     styles->Insert(new_Style(GapText::GetFont(0)), 0, 0, Size());
  696.     return s;
  697. }
  698.  
  699. void StyledText::SetStyle(StChangeStyle mode, int from, int to, StyleSpec st)
  700. {
  701.     int start, end, size;
  702.  
  703.     if (from == to) {
  704.     Style *sp= applyStyleHere ? styleHere : GetStyle(max(0, from-1));
  705.     applyStyleHere= TRUE;
  706.     styleHere= ApplySpec(sp, st, mode);
  707.     } else {
  708.     Style **spp;
  709.     RunArray newStyles(2); 
  710.     styles->Copy(&newStyles, from, to);
  711.     RunArrayIter next(&newStyles);
  712.     while (spp= (Style**)next.RunPtr(&start, &end, &size)) 
  713.         *spp= ApplySpec(*spp, st, mode);
  714.     styles->Paste(&newStyles, from, to, FALSE);
  715.     GetMarkList()->RangeChanged(from, to - from);
  716.     Send(cIdNone, eTextChangedRange, changeRec(from, to));     
  717.     }
  718. }
  719.   
  720. Style *StyledText::ApplySpec(Style *ostyle, StyleSpec st, StChangeStyle mode)
  721. {
  722.     GrFont fid;
  723.     GrFace face;
  724.     int    fsize;
  725.     GrPattern fink;
  726.     
  727.     ostyle->GetStyle (&fid, &face, &fsize, &fink);
  728.     if ((mode & eStFont) == eStFont)
  729.     fid= st.font;
  730.     if ((mode & eStFace) == eStFace)
  731.     if (st.face == eFacePlain)
  732.         face= st.face;
  733.     else {
  734.         if (st.xor)
  735.         face= (GrFace)(face ^ st.face);
  736.         else
  737.         face= (GrFace)(face | st.face);
  738.     }
  739.     if ((mode & eStSize) == eStSize)
  740.     fsize= st.size;
  741.     if ((mode & eStAddSize) == eStAddSize)
  742.     fsize+= st.size;
  743.     if ((mode & eStInk) == eStInk)
  744.     fink= st.ink;
  745.     if (Styles == 0)
  746.     Styles= new StyleTable;
  747.     return Styles->MakeStyle(fid, face, fsize, fink);
  748. }
  749.  
  750. void StyledText::BuildStylesFromString(Style *st, char *buf)
  751. {
  752.     GrFace face= eFacePlain;
  753.     GrFont fid; 
  754.     int run= 0, size;
  755.     GrPattern ink;
  756.     char *p;
  757.  
  758.     styles = new TextRunArray(this);
  759.     for (p= buf; *p; *p++) {
  760.     if (*p == '@') {
  761.         if (*(p+1) && index("OUSBIP",*(p+1))) {
  762.            if (run) {
  763.            st->GetStyle(&fid, &face, &size, &ink);
  764.            int sz= styles->Size();
  765.            styles->Insert(st->DeepClone(), sz, sz, run);
  766.            run = 0;
  767.         }
  768.         p++;
  769.         switch (*p) {
  770.         case 'P':
  771.             face= eFacePlain;
  772.             break;
  773.         case 'O':
  774.             face= (GrFace) (face ^ eFaceOutline);
  775.             break;
  776.         case 'S':
  777.             face= (GrFace) (face ^ eFaceShadow);
  778.             break;
  779.         case 'U':
  780.             face= (GrFace) (face ^ eFaceUnderline);
  781.             break;
  782.         case 'B':
  783.             face= (GrFace) (face ^ eFaceBold);
  784.             break;
  785.         case 'I':
  786.             face= (GrFace) (face ^ eFaceItalic);
  787.             break;
  788.         }
  789.         st= new_Style(fid, face, size);
  790.          } else { 
  791.          p++;
  792.          if (!*p)
  793.              break;
  794.          GapText::Insert(*p, Size(), Size());
  795.          run++;
  796.          }
  797.     } else {
  798.         GapText::Insert(*p, Size(), Size());
  799.         run++;
  800.     }
  801.     }
  802.     if (run) {
  803.     int sz= styles->Size();
  804.     styles->Insert(st->DeepClone(), sz, sz, run);
  805.     }
  806. }
  807.  
  808. Style *StyledText::GetStyle(int at)
  809. {
  810.     int dummy;
  811.     return (Style*) styles->RunAt(at, &dummy, &dummy, &dummy, &dummy);
  812. }
  813.  
  814. void StyledText::SetFont(FontPtr fp)
  815. {
  816.     SetStyle(eStAll, 0, Size(), StyleSpec(fp));
  817. }
  818.  
  819. FontPtr StyledText::GetFont(int at)
  820. {
  821.     Style *st = GetStyle(at);
  822.     if (st)
  823.     return st->GetStyle();
  824.     else
  825.     return GapText::GetFont(at);
  826. }
  827.  
  828. void StyledText::ReplaceStyles(RunArray *st, int from, int to)
  829. {
  830.     if (to-from != st->Size())
  831.     Error("ReplaceStyle", "RunArray does not match text");
  832.     styles->Paste(st,from,to,FALSE);
  833.     GetMarkList()->RangeChanged(from,to - from);
  834.     Send(cIdNone, eTextChangedRange, changeRec(from, to));     
  835. }
  836.  
  837. void StyledText::CopyStyles(RunArray *st,int from, int to)
  838. {
  839.     styles->Copy(st,from,to);
  840. }
  841.  
  842. void StyledText::ResetCurrentStyle()
  843. {
  844.     if (Size())
  845.     applyStyleHere = FALSE;
  846. }
  847.  
  848. const Style *StyledText::GetCurrentStyle()
  849. {
  850.     if (applyStyleHere)
  851.     return styleHere;
  852.     return 0;    
  853. }
  854.  
  855. TextRunArray *StyledText::GetStyles()
  856. {
  857.     return styles; 
  858. }
  859.  
  860. TextRunArray *StyledText::SetStyles(TextRunArray *st)
  861. {
  862.     TextRunArray *old = styles;
  863.     styles = st;
  864.     return old;
  865. }
  866.  
  867. void StyledText::SetEscapeChar(byte ch)
  868. {
  869.     escape = ch;
  870. }
  871.  
  872. byte StyledText::GetEscapeChar()
  873. {
  874.     return escape;
  875. }
  876.  
  877. int StyledText::CalcEscape (int, LineDesc*)
  878. {
  879.     return 0;
  880. }
  881.  
  882. void StyledText::DrawEscape (int,Rectangle)
  883. {
  884. }
  885.  
  886. bool StyledText::IsEscape (int)
  887. {
  888.     return FALSE;
  889. }
  890.  
  891.